/**
 * 树结构相关工具函数
 */

/**
 * 从完整树数据中提取节点配置（递归）
 */
function extractNodesRecursive(node, nodesArray = []) {
    if (!node) return nodesArray;
    
    // ✅ 只保存核心字段，transform数据在节点的transform字段中保存
    const nodeConfig = {
        id: node.id,
        name: node.name,
        type: node.type,
        visible: node.visible !== undefined ? node.visible : true,
        locked: node.locked !== undefined ? node.locked : false,
        userData: node.userData || {}
    };
    
    // ✅ 保留其他额外属性（如 transform、components 等）
    // 注意：不再单独保存 position、rotation、scale，这些数据应该在 transform 字段中
    Object.keys(node).forEach(key => {
        if (!['id', 'name', 'type', 'visible', 'locked', 'userData', 'children', 'position', 'rotation', 'scale', 'modelPath'].includes(key)) {
            nodeConfig[key] = node[key];
        }
    });
    
    nodesArray.push(nodeConfig);
    
    // 递归处理子节点
    if (node.children && node.children.length > 0) {
        node.children.forEach(child => extractNodesRecursive(child, nodesArray));
    }
    
    return nodesArray;
}

/**
 * 构建扁平化的树关系数组
 */
function buildTreeRelations(node, parentId = null, relations = []) {
    if (!node) return relations;
    
    const relation = {
        id: node.id,
        parentId: parentId,
        children: node.children ? node.children.map(child => child.id) : []
    };
    
    relations.push(relation);
    
    // 递归处理子节点
    if (node.children && node.children.length > 0) {
        node.children.forEach(child => {
            buildTreeRelations(child, node.id, relations);
        });
    }
    
    return relations;
}

/**
 * 构建节点的完整路径（从根节点到当前节点的名称链）
 * @param {string} nodeId - 节点ID
 * @param {Array} nodes - 所有节点数组
 * @param {Array} relations - 树关系数组
 * @returns {string} - 完整路径，如 "父节点/子节点/当前节点"（不包含Scene Root）
 */
function buildNodePath(nodeId, nodes, relations) {
    // 创建ID到节点的映射
    const nodeMap = new Map();
    nodes.forEach(node => {
        nodeMap.set(node.id, node);
    });
    
    // 创建ID到关系的映射
    const relationMap = new Map();
    relations.forEach(rel => {
        relationMap.set(rel.id, rel);
    });
    
    // 从当前节点向上追溯到根节点
    const pathNames = [];
    let currentId = nodeId;
    
    while (currentId) {
        const node = nodeMap.get(currentId);
        if (!node) {
            break; // 节点不存在，停止追溯
        }
        
        // 将节点名称添加到路径开头
        pathNames.unshift(node.name);
        
        // 获取父节点ID
        const relation = relationMap.get(currentId);
        if (!relation || !relation.parentId) {
            break; // 已到达根节点
        }
        
        currentId = relation.parentId;
    }
    
    // 移除根节点（通常是 "Scene Root" 或 "root"）
    if (pathNames.length > 0) {
        const firstNode = pathNames[0];
        // 如果第一个节点是根节点，移除它
        if (firstNode === 'Scene Root' || firstNode === 'root' || pathNames[0].toLowerCase().includes('root')) {
            pathNames.shift();
        }
    }
    
    // 如果路径为空（只有根节点），返回当前节点名称
    if (pathNames.length === 0) {
        const node = nodeMap.get(nodeId);
        return node ? node.name : nodeId;
    }
    
    return pathNames.join(' / ');
}

/**
 * 将完整树数据拆分为树关系和节点配置
 */
function splitTreeData(fullTreeData) {
    const root = fullTreeData.root || fullTreeData;
    const nodesArray = extractNodesRecursive(root);
    const treeRelations = buildTreeRelations(root);
    
    return {
        tree: {
            relations: treeRelations,
            nodeCount: nodesArray.length,
            splitAt: new Date().toISOString(),
            version: '2.0'
        },
        nodes: {
            nodes: nodesArray,
            nodeCount: nodesArray.length,
            splitAt: new Date().toISOString(),
            version: '2.0'
        }
    };
}

/**
 * 从relations和nodes重建完整树结构
 */
function rebuildFullTree(relations, nodes) {
    // 创建节点映射表
    const nodesMap = new Map();
    nodes.forEach(node => {
        nodesMap.set(node.id, { ...node });
    });
    
    // 创建关系映射表
    const relationsMap = new Map();
    relations.forEach(rel => {
        relationsMap.set(rel.id, rel);
    });
    
    console.log(`🔧 [rebuildFullTree] 节点数: ${nodes.length}, 关系数: ${relations.length}`);
    
    // 检测孤立的节点引用
    const missingNodes = [];
    relations.forEach(rel => {
        if (rel.children) {
            rel.children.forEach(childId => {
                if (!nodesMap.has(childId)) {
                    missingNodes.push({ parentId: rel.id, childId });
                }
            });
        }
    });
    
    if (missingNodes.length > 0) {
        console.warn(`⚠️ [rebuildFullTree] 检测到 ${missingNodes.length} 个缺失的节点引用，将自动清理：`);
        missingNodes.forEach(m => {
            console.warn(`   - 父节点 ${m.parentId} 引用了不存在的子节点 ${m.childId}`);
        });
    }
    
    // 递归构建树
    function buildNode(nodeId, depth = 0) {
        if (depth > 100) {
            console.error(`❌ [rebuildFullTree] 检测到可能的循环引用，深度超过100层`);
            return null;
        }
        
        const nodeConfig = nodesMap.get(nodeId);
        const relation = relationsMap.get(nodeId);
        
        if (!nodeConfig) {
            console.warn(`⚠️ [rebuildFullTree] 节点配置不存在: ${nodeId}`);
            return null;
        }
        
        if (!relation) {
            console.warn(`⚠️ [rebuildFullTree] 节点关系不存在: ${nodeId}`);
            return null;
        }
        
        // 构建节点
        const node = { ...nodeConfig };
        
        // 添加子节点
        if (relation.children && relation.children.length > 0) {
            node.children = relation.children
                .map(childId => buildNode(childId, depth + 1))
                .filter(child => child !== null);
        } else {
            node.children = [];
        }
        
        return node;
    }
    
    // 从root节点开始构建
    const result = buildNode('root');
    
    if (!result) {
        console.error(`❌ [rebuildFullTree] 无法构建根节点`);
        throw new Error('无法构建场景树：根节点缺失');
    }
    
    return result;
}

module.exports = {
    extractNodesRecursive,
    buildTreeRelations,
    buildNodePath,
    splitTreeData,
    rebuildFullTree
};

